using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("iTween")]
	public class iTween : MonoClass
	{
		public enum EaseType
		{
			easeInQuad,
			easeOutQuad,
			easeInOutQuad,
			easeInCubic,
			easeOutCubic,
			easeInOutCubic,
			easeInQuart,
			easeOutQuart,
			easeInOutQuart,
			easeInQuint,
			easeOutQuint,
			easeInOutQuint,
			easeInSine,
			easeOutSine,
			easeInOutSine,
			easeInExpo,
			easeOutExpo,
			easeInOutExpo,
			easeInCirc,
			easeOutCirc,
			easeInOutCirc,
			linear,
			spring,
			easeInBounce,
			easeOutBounce,
			easeInOutBounce,
			easeInBack,
			easeOutBack,
			easeInOutBack,
			easeInElastic,
			easeOutElastic,
			easeInOutElastic,
			punch,
			easeInSineOutExpo,
			easeOutElasticLight
		}

		public enum CallbackType
		{
			OnStart,
			OnUpdate,
			OnComplete,
			OnConflict
		}

		public enum LoopType
		{
			none,
			loop,
			pingPong
		}

		public enum NamedValueColor
		{
			_Color,
			_SpecColor,
			_Emission,
			_ReflectColor
		}

		[Attribute38("iTween.Defaults")]
		public class Defaults : MonoClass
		{
			public static float time => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "time");

			public static float delay => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "delay");

			public static NamedValueColor namedColorValue => MonoClass.smethod_6<NamedValueColor>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "namedColorValue");

			public static LoopType loopType => MonoClass.smethod_6<LoopType>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "loopType");

			public static EaseType easeType => MonoClass.smethod_6<EaseType>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "easeType");

			public static float lookSpeed => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "lookSpeed");

			public static bool isLocal => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "isLocal");

			public static Space space => MonoClass.smethod_6<Space>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "space");

			public static bool orientToPath => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "orientToPath");

			public static Color color => MonoClass.smethod_6<Color>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "color");

			public static float updateTimePercentage => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "updateTimePercentage");

			public static float updateTime => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "updateTime");

			public static int cameraFadeDepth => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "cameraFadeDepth");

			public static float lookAhead => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "lookAhead");

			public static bool useRealTime => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "useRealTime");

			public static Vector3 up => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "iTween/Defaults", "up");

			public Defaults(IntPtr address, string className)
				: base(address, className)
			{
			}

			public Defaults(IntPtr address)
				: this(address, "Defaults")
			{
			}
		}

		[Attribute38("iTween.CRSpline")]
		public class CRSpline : MonoClass
		{
			public List<Vector3> pts => method_3<Class250<Vector3>>("pts")?.method_25();

			public CRSpline(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CRSpline(IntPtr address)
				: this(address, "CRSpline")
			{
			}

			public Vector3 Interp(float t)
			{
				return method_11<Vector3>("Interp", new object[1] { t });
			}
		}

		public static GameObject cameraFade => MonoClass.smethod_7<GameObject>(TritonHs.MainAssemblyPath, "", "iTween", "cameraFade");

		public static int nextId => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "iTween", "nextId");

		public int id => method_2<int>("id");

		public string type => method_4("type");

		public string method => method_4("method");

		public EaseType easeType => method_2<EaseType>("easeType");

		public float time => method_2<float>("time");

		public float delay => method_2<float>("delay");

		public LoopType loopType => method_2<LoopType>("loopType");

		public bool isRunning => method_2<bool>("isRunning");

		public bool isPaused => method_2<bool>("isPaused");

		public string _name => method_4("_name");

		public bool waitForDelay => method_2<bool>("waitForDelay");

		public float runningTime => method_2<float>("runningTime");

		public float percentage => method_2<float>("percentage");

		public float delayStarted => method_2<float>("delayStarted");

		public bool kinematic => method_2<bool>("kinematic");

		public bool isLocal => method_2<bool>("isLocal");

		public bool loop => method_2<bool>("loop");

		public bool reverse => method_2<bool>("reverse");

		public bool physics => method_2<bool>("physics");

		public Space space => method_2<Space>("space");

		public List<Vector3> vector3s => method_3<Class250<Vector3>>("vector3s")?.method_25();

		public List<Vector2> vector2s => method_3<Class250<Vector2>>("vector2s")?.method_25();

		public List<Color> colors => method_3<Class250<Color>>("colors")?.method_25();

		public List<float> floats => method_3<Class250<float>>("floats")?.method_25();

		public List<Rect> rects => method_3<Class250<Rect>>("rects")?.method_25();

		public CRSpline path => method_3<CRSpline>("path");

		public Vector3 preUpdate => method_2<Vector3>("preUpdate");

		public Vector3 postUpdate => method_2<Vector3>("postUpdate");

		public NamedValueColor namedcolorvalue => method_2<NamedValueColor>("namedcolorvalue");

		public string namedColorValueString => method_4("namedColorValueString");

		public float lastRealTime => method_2<float>("lastRealTime");

		public bool useRealTime => method_2<bool>("useRealTime");

		public GameObject gameObject => method_3<GameObject>("gameObject");

		public bool enabled => method_2<bool>("enabled");

		public bool activeLastTick => method_2<bool>("activeLastTick");

		public bool destroyed => method_2<bool>("destroyed");

		public static List<string> CALLBACK_NAMES => MonoClass.smethod_7<Class249>(TritonHs.MainAssemblyPath, "", "iTween", "CALLBACK_NAMES")?.method_25();

		public static List<string> CALLBACK_TARGET_NAMES => MonoClass.smethod_7<Class249>(TritonHs.MainAssemblyPath, "", "iTween", "CALLBACK_TARGET_NAMES")?.method_25();

		public static List<string> CALLBACK_PARAMS_NAMES => MonoClass.smethod_7<Class249>(TritonHs.MainAssemblyPath, "", "iTween", "CALLBACK_PARAMS_NAMES")?.method_25();

		public Transform transform => method_14<Transform>("get_transform", Array.Empty<object>());

		public Renderer renderer => method_14<Renderer>("get_renderer", Array.Empty<object>());

		public GUITexture guiTexture => method_14<GUITexture>("get_guiTexture", Array.Empty<object>());

		public bool activeInHierarchy => method_11<bool>("get_activeInHierarchy", Array.Empty<object>());

		public iTween(IntPtr address, string className)
			: base(address, className)
		{
		}

		public iTween(IntPtr address)
			: this(address, "iTween")
		{
		}

		public static void Init(GameObject target)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "iTween", "Init", target);
		}

		public static void CameraFadeFrom(float amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "CameraFadeFrom", new Class276.Enum20[2]
			{
				Class276.Enum20.R4,
				Class276.Enum20.R4
			}, amount, time);
		}

		public static void CameraFadeTo(float amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "CameraFadeTo", new Class276.Enum20[2]
			{
				Class276.Enum20.R4,
				Class276.Enum20.R4
			}, amount, time);
		}

		public static void FadeFrom(GameObject target, float alpha, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "FadeFrom", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.R4,
				Class276.Enum20.R4
			}, target, alpha, time);
		}

		public static void FadeTo(GameObject target, float alpha, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "FadeTo", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.R4,
				Class276.Enum20.R4
			}, target, alpha, time);
		}

		public static void ColorFrom(GameObject target, Color color, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ColorFrom", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, color, time);
		}

		public static void ColorTo(GameObject target, Color color, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ColorTo", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, color, time);
		}

		public static void AudioFrom(GameObject target, float volume, float pitch, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "AudioFrom", new Class276.Enum20[4]
			{
				Class276.Enum20.Class,
				Class276.Enum20.R4,
				Class276.Enum20.R4,
				Class276.Enum20.R4
			}, target, volume, pitch, time);
		}

		public static void AudioTo(GameObject target, float volume, float pitch, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "AudioTo", new Class276.Enum20[4]
			{
				Class276.Enum20.Class,
				Class276.Enum20.R4,
				Class276.Enum20.R4,
				Class276.Enum20.R4
			}, target, volume, pitch, time);
		}

		public static void LookFrom(GameObject target, Vector3 looktarget, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "LookFrom", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, looktarget, time);
		}

		public static void LookTo(GameObject target, Vector3 looktarget, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "LookTo", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, looktarget, time);
		}

		public static void MoveTo(GameObject target, Vector3 position, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "MoveTo", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, position, time);
		}

		public static void MoveFrom(GameObject target, Vector3 position, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "MoveFrom", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, position, time);
		}

		public static void MoveAdd(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "MoveAdd", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void MoveBy(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "MoveBy", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void ScaleTo(GameObject target, Vector3 scale, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ScaleTo", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, scale, time);
		}

		public static void ScaleFrom(GameObject target, Vector3 scale, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ScaleFrom", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, scale, time);
		}

		public static void ScaleAdd(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ScaleAdd", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void ScaleBy(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ScaleBy", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void RotateTo(GameObject target, Vector3 rotation, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "RotateTo", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, rotation, time);
		}

		public static void RotateFrom(GameObject target, Vector3 rotation, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "RotateFrom", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, rotation, time);
		}

		public static void RotateAdd(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "RotateAdd", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void RotateBy(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "RotateBy", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void ShakePosition(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ShakePosition", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void ShakeScale(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ShakeScale", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void ShakeRotation(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ShakeRotation", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void PunchPosition(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "PunchPosition", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void PunchRotation(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "PunchRotation", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static void PunchScale(GameObject target, Vector3 amount, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "PunchScale", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, amount, time);
		}

		public static Rect RectUpdate(Rect currentValue, Rect targetValue, float speed)
		{
			return MonoClass.smethod_14<Rect>(TritonHs.MainAssemblyPath, "", "iTween", "RectUpdate", new object[3] { currentValue, targetValue, speed });
		}

		public static Vector3 Vector3Update(Vector3 currentValue, Vector3 targetValue, float speed)
		{
			return MonoClass.smethod_14<Vector3>(TritonHs.MainAssemblyPath, "", "iTween", "Vector3Update", new object[3] { currentValue, targetValue, speed });
		}

		public static Vector2 Vector2Update(Vector2 currentValue, Vector2 targetValue, float speed)
		{
			return MonoClass.smethod_14<Vector2>(TritonHs.MainAssemblyPath, "", "iTween", "Vector2Update", new object[3] { currentValue, targetValue, speed });
		}

		public static float FloatUpdate(float currentValue, float targetValue, float speed)
		{
			return MonoClass.smethod_14<float>(TritonHs.MainAssemblyPath, "", "iTween", "FloatUpdate", new object[3] { currentValue, targetValue, speed });
		}

		public static void FadeUpdate(GameObject target, float alpha, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "FadeUpdate", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.R4,
				Class276.Enum20.R4
			}, target, alpha, time);
		}

		public static void ColorUpdate(GameObject target, Color color, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ColorUpdate", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, color, time);
		}

		public static void AudioUpdate(GameObject target, float volume, float pitch, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "AudioUpdate", new Class276.Enum20[4]
			{
				Class276.Enum20.Class,
				Class276.Enum20.R4,
				Class276.Enum20.R4,
				Class276.Enum20.R4
			}, target, volume, pitch, time);
		}

		public static void RotateUpdate(GameObject target, Vector3 rotation, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "RotateUpdate", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, rotation, time);
		}

		public static void ScaleUpdate(GameObject target, Vector3 scale, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "ScaleUpdate", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, scale, time);
		}

		public static void MoveUpdate(GameObject target, Vector3 position, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "MoveUpdate", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, position, time);
		}

		public static void LookUpdate(GameObject target, Vector3 looktarget, float time)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "LookUpdate", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.R4
			}, target, looktarget, time);
		}

		public static void CameraFadeDepth(int depth)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "iTween", "CameraFadeDepth", depth);
		}

		public static void CameraFadeDestroy()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "iTween", "CameraFadeDestroy");
		}

		public static GameObject CameraFadeAdd()
		{
			return MonoClass.smethod_16<GameObject>(TritonHs.MainAssemblyPath, "", "iTween", "CameraFadeAdd", new Class276.Enum20[0], Array.Empty<object>());
		}

		public static void EnableTween(iTween tween)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "iTween", "EnableTween", tween);
		}

		public static void Resume(GameObject target)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Resume", new Class276.Enum20[1] { Class276.Enum20.Class }, target);
		}

		public static void Resume(GameObject target, bool includechildren)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Resume", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean
			}, target, includechildren);
		}

		public static void Resume(GameObject target, string type)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Resume", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String
			}, target, type);
		}

		public static void Resume(GameObject target, string type, bool includechildren)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Resume", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String,
				Class276.Enum20.Boolean
			}, target, type, includechildren);
		}

		public static void Resume()
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Resume", new Class276.Enum20[0]);
		}

		public static void Resume(string type)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Resume", new Class276.Enum20[1] { Class276.Enum20.String }, type);
		}

		public static void PauseTween(iTween tween)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "iTween", "PauseTween", tween);
		}

		public static void Pause(GameObject target)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Pause", new Class276.Enum20[1] { Class276.Enum20.Class }, target);
		}

		public static void Pause(GameObject target, bool includechildren)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Pause", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean
			}, target, includechildren);
		}

		public static void Pause(GameObject target, string type)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Pause", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String
			}, target, type);
		}

		public static void Pause(GameObject target, string type, bool includechildren)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Pause", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String,
				Class276.Enum20.Boolean
			}, target, type, includechildren);
		}

		public static void Pause()
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Pause", new Class276.Enum20[0]);
		}

		public static void Pause(string type)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Pause", new Class276.Enum20[1] { Class276.Enum20.String }, type);
		}

		public static int Count()
		{
			return MonoClass.smethod_11<int>(TritonHs.MainAssemblyPath, "", "iTween", "Count", new Class276.Enum20[0], Array.Empty<object>());
		}

		public static int Count(string type)
		{
			return MonoClass.smethod_11<int>(TritonHs.MainAssemblyPath, "", "iTween", "Count", new Class276.Enum20[1] { Class276.Enum20.String }, new object[1] { type });
		}

		public static int Count(GameObject target)
		{
			return MonoClass.smethod_11<int>(TritonHs.MainAssemblyPath, "", "iTween", "Count", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { target });
		}

		public static int Count(GameObject target, string type)
		{
			return MonoClass.smethod_11<int>(TritonHs.MainAssemblyPath, "", "iTween", "Count", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String
			}, new object[2] { target, type });
		}

		public static int CountByName(GameObject target, string name)
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "iTween", "CountByName", new object[2] { target, name });
		}

		public static int CountOtherTypes(GameObject target, string type)
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "iTween", "CountOtherTypes", new object[2] { target, type });
		}

		public static int CountOtherNames(GameObject target, string name)
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "iTween", "CountOtherNames", new object[2] { target, name });
		}

		public static bool HasTween(GameObject target)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "iTween", "HasTween", new object[1] { target });
		}

		public static bool HasType(GameObject target, string type)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "iTween", "HasType", new object[2] { target, type });
		}

		public static bool HasName(GameObject target, string name)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "iTween", "HasName", new object[2] { target, name });
		}

		public static bool HasOtherType(GameObject target, string type)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "iTween", "HasOtherType", new object[2] { target, type });
		}

		public static bool HasOtherName(GameObject target, string name)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "iTween", "HasOtherName", new object[2] { target, name });
		}

		public static void StopTween(iTween tween)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "iTween", "StopTween", tween);
		}

		public static void Stop()
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Stop", new Class276.Enum20[0]);
		}

		public static void Stop(string type)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Stop", new Class276.Enum20[1] { Class276.Enum20.String }, type);
		}

		public static void StopByName(string name)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "StopByName", new Class276.Enum20[1] { Class276.Enum20.String }, name);
		}

		public static void Stop(GameObject target)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Stop", new Class276.Enum20[1] { Class276.Enum20.Class }, target);
		}

		public static void Stop(GameObject target, bool includechildren)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Stop", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean
			}, target, includechildren);
		}

		public static void Stop(GameObject target, string type)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Stop", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String
			}, target, type);
		}

		public static void StopByName(GameObject target, string name)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "StopByName", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String
			}, target, name);
		}

		public static void Stop(GameObject target, string type, bool includechildren)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "Stop", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String,
				Class276.Enum20.Boolean
			}, target, type, includechildren);
		}

		public static void StopByName(GameObject target, string name, bool includechildren)
		{
			MonoClass.smethod_19(TritonHs.MainAssemblyPath, "", "iTween", "StopByName", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String,
				Class276.Enum20.Boolean
			}, target, name, includechildren);
		}

		public static void StopOthers(GameObject target, string type, bool includechildren)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "iTween", "StopOthers", target, type, includechildren);
		}

		public static void StopOthersByName(GameObject target, string name, bool includechildren)
		{
			MonoClass.smethod_18(TritonHs.MainAssemblyPath, "", "iTween", "StopOthersByName", target, name, includechildren);
		}

		public static int GenerateID()
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "iTween", "GenerateID", Array.Empty<object>());
		}

		public Component GetComponent(Type t)
		{
			return method_14<Component>("GetComponent", new object[1] { t });
		}

		public void GenerateTargets()
		{
			method_8("GenerateTargets");
		}

		public void GenerateRectTargets()
		{
			method_8("GenerateRectTargets");
		}

		public void GenerateColorTargets()
		{
			method_8("GenerateColorTargets");
		}

		public void GenerateVector3Targets()
		{
			method_8("GenerateVector3Targets");
		}

		public void GenerateVector2Targets()
		{
			method_8("GenerateVector2Targets");
		}

		public void GenerateFloatTargets()
		{
			method_8("GenerateFloatTargets");
		}

		public void GenerateColorToTargets()
		{
			method_8("GenerateColorToTargets");
		}

		public void GenerateAudioToTargets()
		{
			method_8("GenerateAudioToTargets");
		}

		public void GenerateStabTargets()
		{
			method_8("GenerateStabTargets");
		}

		public void GenerateLookToTargets()
		{
			method_8("GenerateLookToTargets");
		}

		public void GenerateMoveToPathTargets()
		{
			method_8("GenerateMoveToPathTargets");
		}

		public void GenerateMoveToTargets()
		{
			method_8("GenerateMoveToTargets");
		}

		public void GenerateMoveByTargets()
		{
			method_8("GenerateMoveByTargets");
		}

		public void GenerateScaleToTargets()
		{
			method_8("GenerateScaleToTargets");
		}

		public void GenerateScaleByTargets()
		{
			method_8("GenerateScaleByTargets");
		}

		public void GenerateScaleAddTargets()
		{
			method_8("GenerateScaleAddTargets");
		}

		public void GenerateRotateToTargets()
		{
			method_8("GenerateRotateToTargets");
		}

		public void GenerateRotateAddTargets()
		{
			method_8("GenerateRotateAddTargets");
		}

		public void GenerateRotateByTargets()
		{
			method_8("GenerateRotateByTargets");
		}

		public void GenerateShakePositionTargets()
		{
			method_8("GenerateShakePositionTargets");
		}

		public void GenerateShakeScaleTargets()
		{
			method_8("GenerateShakeScaleTargets");
		}

		public void GenerateShakeRotationTargets()
		{
			method_8("GenerateShakeRotationTargets");
		}

		public void GeneratePunchPositionTargets()
		{
			method_8("GeneratePunchPositionTargets");
		}

		public void GeneratePunchRotationTargets()
		{
			method_8("GeneratePunchRotationTargets");
		}

		public void GeneratePunchScaleTargets()
		{
			method_8("GeneratePunchScaleTargets");
		}

		public void ApplyRectTargets()
		{
			method_8("ApplyRectTargets");
		}

		public void ApplyColorTargets()
		{
			method_8("ApplyColorTargets");
		}

		public void ApplyVector3Targets()
		{
			method_8("ApplyVector3Targets");
		}

		public void ApplyVector2Targets()
		{
			method_8("ApplyVector2Targets");
		}

		public void ApplyFloatTargets()
		{
			method_8("ApplyFloatTargets");
		}

		public void ApplyColorToTargets()
		{
			method_8("ApplyColorToTargets");
		}

		public void ApplyAudioToTargets()
		{
			method_8("ApplyAudioToTargets");
		}

		public void ApplyStabTargets()
		{
			method_8("ApplyStabTargets");
		}

		public void ApplyMoveToPathTargets()
		{
			method_8("ApplyMoveToPathTargets");
		}

		public void ApplyMoveToTargets()
		{
			method_8("ApplyMoveToTargets");
		}

		public void ApplyMoveByTargets()
		{
			method_8("ApplyMoveByTargets");
		}

		public void ApplyScaleToTargets()
		{
			method_8("ApplyScaleToTargets");
		}

		public void ApplyLookToTargets()
		{
			method_8("ApplyLookToTargets");
		}

		public void ApplyRotateToTargets()
		{
			method_8("ApplyRotateToTargets");
		}

		public void ApplyRotateAddTargets()
		{
			method_8("ApplyRotateAddTargets");
		}

		public void ApplyShakePositionTargets()
		{
			method_8("ApplyShakePositionTargets");
		}

		public void ApplyShakeScaleTargets()
		{
			method_8("ApplyShakeScaleTargets");
		}

		public void ApplyShakeRotationTargets()
		{
			method_8("ApplyShakeRotationTargets");
		}

		public void ApplyPunchPositionTargets()
		{
			method_8("ApplyPunchPositionTargets");
		}

		public void ApplyPunchRotationTargets()
		{
			method_8("ApplyPunchRotationTargets");
		}

		public void ApplyPunchScaleTargets()
		{
			method_8("ApplyPunchScaleTargets");
		}

		public void ResetDelay()
		{
			method_8("ResetDelay");
		}

		public void TweenStart()
		{
			method_8("TweenStart");
		}

		public void TweenRestart()
		{
			method_8("TweenRestart");
		}

		public void TweenUpdate()
		{
			method_8("TweenUpdate");
		}

		public void TweenComplete()
		{
			method_8("TweenComplete");
		}

		public void TweenLoop()
		{
			method_8("TweenLoop");
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void Update()
		{
			method_8("Update");
		}

		public void FixedUpdate()
		{
			method_8("FixedUpdate");
		}

		public void LateUpdate()
		{
			method_8("LateUpdate");
		}

		public void OnEnable()
		{
			method_8("OnEnable");
		}

		public void OnDisable()
		{
			method_8("OnDisable");
		}

		public void Upkeep()
		{
			method_8("Upkeep");
		}

		public Vector3 GetTargetPosition()
		{
			return method_11<Vector3>("GetTargetPosition", Array.Empty<object>());
		}

		public void RetrieveArgs()
		{
			method_8("RetrieveArgs");
		}

		public void GetEasingFunction()
		{
			method_8("GetEasingFunction");
		}

		public void UpdatePercentage()
		{
			method_8("UpdatePercentage");
		}

		public void CallBack(CallbackType callbackType)
		{
			method_8("CallBack", callbackType);
		}

		public new void Dispose()
		{
			method_8("Dispose");
		}

		public void ConflictCheck()
		{
			method_8("ConflictCheck");
		}

		public void EnableKinematic()
		{
			method_8("EnableKinematic");
		}

		public void DisableKinematic()
		{
			method_8("DisableKinematic");
		}

		public void ResumeDelay()
		{
			method_8("ResumeDelay");
		}

		public float linear(float start, float end, float value)
		{
			return method_11<float>("linear", new object[3] { start, end, value });
		}

		public float clerp(float start, float end, float value)
		{
			return method_11<float>("clerp", new object[3] { start, end, value });
		}

		public float spring(float start, float end, float value)
		{
			return method_11<float>("spring", new object[3] { start, end, value });
		}

		public float easeInQuad(float start, float end, float value)
		{
			return method_11<float>("easeInQuad", new object[3] { start, end, value });
		}

		public float easeOutQuad(float start, float end, float value)
		{
			return method_11<float>("easeOutQuad", new object[3] { start, end, value });
		}

		public float easeInOutQuad(float start, float end, float value)
		{
			return method_11<float>("easeInOutQuad", new object[3] { start, end, value });
		}

		public float easeInCubic(float start, float end, float value)
		{
			return method_11<float>("easeInCubic", new object[3] { start, end, value });
		}

		public float easeOutCubic(float start, float end, float value)
		{
			return method_11<float>("easeOutCubic", new object[3] { start, end, value });
		}

		public float easeInOutCubic(float start, float end, float value)
		{
			return method_11<float>("easeInOutCubic", new object[3] { start, end, value });
		}

		public float easeInQuart(float start, float end, float value)
		{
			return method_11<float>("easeInQuart", new object[3] { start, end, value });
		}

		public float easeOutQuart(float start, float end, float value)
		{
			return method_11<float>("easeOutQuart", new object[3] { start, end, value });
		}

		public float easeInOutQuart(float start, float end, float value)
		{
			return method_11<float>("easeInOutQuart", new object[3] { start, end, value });
		}

		public float easeInQuint(float start, float end, float value)
		{
			return method_11<float>("easeInQuint", new object[3] { start, end, value });
		}

		public float easeOutQuint(float start, float end, float value)
		{
			return method_11<float>("easeOutQuint", new object[3] { start, end, value });
		}

		public float easeInOutQuint(float start, float end, float value)
		{
			return method_11<float>("easeInOutQuint", new object[3] { start, end, value });
		}

		public float easeInSine(float start, float end, float value)
		{
			return method_11<float>("easeInSine", new object[3] { start, end, value });
		}

		public float easeOutSine(float start, float end, float value)
		{
			return method_11<float>("easeOutSine", new object[3] { start, end, value });
		}

		public float easeInOutSine(float start, float end, float value)
		{
			return method_11<float>("easeInOutSine", new object[3] { start, end, value });
		}

		public float easeInExpo(float start, float end, float value)
		{
			return method_11<float>("easeInExpo", new object[3] { start, end, value });
		}

		public float easeOutExpo(float start, float end, float value)
		{
			return method_11<float>("easeOutExpo", new object[3] { start, end, value });
		}

		public float easeInOutExpo(float start, float end, float value)
		{
			return method_11<float>("easeInOutExpo", new object[3] { start, end, value });
		}

		public float easeInCirc(float start, float end, float value)
		{
			return method_11<float>("easeInCirc", new object[3] { start, end, value });
		}

		public float easeOutCirc(float start, float end, float value)
		{
			return method_11<float>("easeOutCirc", new object[3] { start, end, value });
		}

		public float easeInOutCirc(float start, float end, float value)
		{
			return method_11<float>("easeInOutCirc", new object[3] { start, end, value });
		}

		public float easeInBounce(float start, float end, float value)
		{
			return method_11<float>("easeInBounce", new object[3] { start, end, value });
		}

		public float easeOutBounce(float start, float end, float value)
		{
			return method_11<float>("easeOutBounce", new object[3] { start, end, value });
		}

		public float easeInOutBounce(float start, float end, float value)
		{
			return method_11<float>("easeInOutBounce", new object[3] { start, end, value });
		}

		public float easeInBack(float start, float end, float value)
		{
			return method_11<float>("easeInBack", new object[3] { start, end, value });
		}

		public float easeOutBack(float start, float end, float value)
		{
			return method_11<float>("easeOutBack", new object[3] { start, end, value });
		}

		public float easeInOutBack(float start, float end, float value)
		{
			return method_11<float>("easeInOutBack", new object[3] { start, end, value });
		}

		public float punch(float amplitude, float value)
		{
			return method_11<float>("punch", new object[2] { amplitude, value });
		}

		public float easeInElastic(float start, float end, float value)
		{
			return method_11<float>("easeInElastic", new object[3] { start, end, value });
		}

		public float easeOutElastic(float start, float end, float value)
		{
			return method_11<float>("easeOutElastic", new object[3] { start, end, value });
		}

		public float easeOutElasticLight(float start, float end, float value)
		{
			return method_11<float>("easeOutElasticLight", new object[3] { start, end, value });
		}

		public float easeInOutElastic(float start, float end, float value)
		{
			return method_11<float>("easeInOutElastic", new object[3] { start, end, value });
		}

		public float easeInSineOutExpo(float start, float end, float value)
		{
			return method_11<float>("easeInSineOutExpo", new object[3] { start, end, value });
		}

		public float easeInExpoFirstHalf(float start, float end, float value)
		{
			return method_11<float>("easeInExpoFirstHalf", new object[3] { start, end, value });
		}

		public float easeInExpoSecondHalf(float start, float end, float value)
		{
			return method_11<float>("easeInExpoSecondHalf", new object[3] { start, end, value });
		}

		public new string ToString()
		{
			return method_13("ToString");
		}
	}
}
